home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / incl / LEDA.020+881 / list.h < prev    next >
C/C++ Source or Header  |  1994-08-05  |  5KB  |  145 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  list.h
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16. #ifndef LEDA_LIST_H
  17. #define LEDA_LIST_H
  18.  
  19. #include <LEDA/impl/dlist.h>
  20.  
  21.  
  22. template<class type> 
  23.  
  24. class _CLASSTYPE list : public dlist 
  25. {
  26.  
  27. type X;
  28.  
  29. int  cmp(GenPtr x, GenPtr y) const
  30.                             { return compare(ACCESS(type,x),ACCESS(type,y));}
  31. void print_el(GenPtr& x,ostream& out) const { Print(ACCESS(type,x),out);  }
  32. void read_el(GenPtr& x,istream& in)   { Read(X,in); x = Copy(X); }
  33. void clear_el(GenPtr& x)              const { Clear(ACCESS(type,x)); }
  34. void copy_el(GenPtr& x)               const { x = Copy(ACCESS(type,x)); }
  35.  
  36. int  int_type() const { return INT_TYPE(type); }
  37.  
  38. public:
  39.  
  40. list_item push(type a)   { return dlist::push(Copy(a));}
  41. list_item append(type a) { return dlist::append(Copy(a));}
  42. list_item insert(type a, list_item l, int dir=0)
  43.                          { return dlist::insert(Copy(a),l,dir); }
  44.  
  45. type  contents(list_item l) const { return ACCESS(type,dlist::contents(l)); }
  46. type  inf(list_item l)      const { return contents(l); }
  47.  
  48. GenPtr forall_loop_test(GenPtr it, type& x) const
  49. { if (it) x = contents(list_item(it));
  50.   return it;
  51.  }
  52.  
  53. type  head()                const { return ACCESS(type,dlist::head()); }
  54. type  tail()                const { return ACCESS(type,dlist::tail()); }
  55.  
  56.  
  57. type  pop() { GenPtr x=dlist::pop(); 
  58.               type   y=ACCESS(type,x); 
  59.               Clear(ACCESS(type,x)); 
  60.               return y; }
  61.  
  62. type  Pop() { GenPtr x=dlist::Pop(); 
  63.               type   y=ACCESS(type,x); 
  64.               Clear(ACCESS(type,x)); 
  65.               return y; }
  66.  
  67. type  del_item(list_item a) { GenPtr x=dlist::del(a);
  68.                               type   y=ACCESS(type,x);
  69.                               Clear(ACCESS(type,x));
  70.                               return y; }
  71.  
  72. type  del(list_item a)           { return del_item(a); }
  73.  
  74. void  assign(list_item p,type a) { dlist::assign(p,Copy(a));}
  75.  
  76. void  conc(list<type>& l)              { dlist::conc((dlist&)l); }
  77. void  split(list_item p, list<type>& l1, list<type>& l2)
  78.                                  { dlist::split(p,(dlist&)l1,(dlist&)l2);}
  79.  
  80. list_item search(type a) const   { return dlist::search(Convert(a)); }
  81. int       rank(type a)   const   { return dlist::rank(Convert(a)); }
  82.  
  83. list_item max()                      { return dlist::max(0); }
  84. list_item min()                      { return dlist::min(0); }
  85. list_item max(int (*f)(const type&,const type&)) 
  86.                                      { return dlist::max(CMP_PTR(f)); }
  87. list_item min(int (*f)(const type&,const type&)) 
  88.                                      { return dlist::min(CMP_PTR(f)); }
  89.  
  90. void  sort()                         { dlist::sort(0); }
  91. void  sort(int (*f)(const type&,const type&))  { dlist::sort(CMP_PTR(f)); }
  92.  
  93. void  apply(void (*f)(type&))   { dlist::apply(APP_PTR(f)); }
  94.  
  95. void  bucket_sort(int i, int j, int (*f)(const type&))
  96.                                      { dlist::bucket_sort(i,j,ORD_PTR(f)); }
  97.  
  98. list_item read_iterator(type& x) const 
  99. { GenPtr y; 
  100.   dlink* p=dlist::read_iterator(y);
  101.   if (p) x = ACCESS(type,y); 
  102.   return p; }
  103.  
  104. bool current_element(type& x) const {GenPtr y; bool b=dlist::current_element(y);
  105.                                      if (b) x = ACCESS(type,y); return b; }
  106. bool next_element(type& x)   const  {GenPtr y; bool b = dlist::next_element(y);
  107.                                      if (b) x = ACCESS(type,y); return b; }
  108. bool prev_element(type& x)   const  {GenPtr y; bool b = dlist::prev_element(y);
  109.                                      if (b) x = ACCESS(type,y); return b; }
  110.  
  111.  list() {}
  112.  list(type a)        : dlist(Copy(a)){}
  113.  
  114.  list(const list<type>& a) : dlist(a) {}
  115.  
  116. virtual ~list() { clear(); }
  117.  
  118. list<type>& operator=(const list<type>& a) 
  119. { dlist::operator=(a); return *this;}
  120.  
  121. #if !defined(__sgi)
  122. list<type>  operator+(const list<type>& a) 
  123. { dlist L = *(dlist*)this + *(dlist*)&a; return *(list<type>*)&L; }
  124. #endif
  125.  
  126. list_item operator+=(type x)   { return append(x); }
  127. list_item operator[](int i)    { return get_item(i); }
  128.  
  129. type&  operator[](list_item p) { return ACCESS(type,dlist::entry(p)); }
  130. type   operator[](list_item p) const { return contents(p); }
  131.  
  132. }; 
  133.  
  134.  
  135. //------------------------------------------------------------------------------
  136. // Iteration Macros
  137. //------------------------------------------------------------------------------
  138.  
  139. #define forall_list_items(a,L) for( a=(L).first(); a ; a=(L).succ(a) )
  140. #define Forall_list_items(a,L) for( a=(L).last();  a ; a=(L).pred(a) )
  141.  
  142.  
  143.  
  144. #endif
  145.